home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Tournament Islands / Tournament Islands Tiny.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  50.1 KB  |  1,531 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Tournament Islands Tiny.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Creator: Richard Bishop $
  10. // $Version: 1.0 $
  11. // $Date:
  12. //
  13. //////////////////////////////////////////////////////////////////////
  14.  
  15. #if            NOTDEFINED(TOURNAMENT_ISLANDS_TINY_RMV)
  16. #define        (TOURNAMENT_ISLANDS_TINY_RMV,1)
  17.  
  18. //////////////////////////////////////////////////////////////////////
  19. // Definitions we are required to define for small island maps
  20. //////////////////////////////////////////////////////////////////////
  21.  
  22. ResourcePlacementLimit (Gold,     6,    7)
  23. ResourcePlacementLimit (Steel,     6,     7)
  24. ResourcePlacementLimit (Stone,     6,     7)
  25. ResourcePlacementLimit (Berry,     7,     8)
  26. ResourcePlacementLimit (Fish,     1,    45)
  27. ResourcePlacementLimit (Tree,     3,     7)
  28. ResourcePlacementLimit (Animal, 3,     15)
  29.  
  30. #if Is2Players
  31. //////////////////////////////////////////////////////////////////////
  32. // 2 PLAYERS...
  33. //////////////////////////////////////////////////////////////////////
  34.  
  35. PlaceWorldUnitInRing (Res-GoldMine, 10, 12)
  36. PlaceWorldUnitInRing (Res-Iron, 10, 12)
  37.  
  38. //////////////////////////////////////////////////////////////////////
  39. // terrain definitions
  40. #define        (kMinIntElevation,                -8)
  41. #define        (kMaxIntElevation,                8)
  42. #define        (kElevationScale,                      1)
  43. #define        (kPercentLand,                    Between(0.32, 0.32))
  44. #define        (kWaterBorder,                    0)
  45. #define        (kRiverWidth,                    8)
  46. #define        (kCoastToDeepWaterPercentage                  1.0)
  47. #define        (kHeightMapChaos,                    Between(15, 15))
  48.         
  49. #define        (kMinimumStartPositionToMapEdge            0)
  50. #define        (kOuterPushFromMapCenter            14)
  51. #define        (kInnerPushFromMapCenter             0)                                    
  52.  
  53. //////////////////////////////////////////////////////////////////////
  54. // player definitions
  55. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  56. #define        (kPlayerInnerRadius,            0.5)
  57. #define        (kPlayerOuterRadius,            0.9)
  58. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  59. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  60. #define        (kPlayerLandChaos,            1)
  61. #define        (kPlayerLandClumps,            1)
  62. #define        (kPlayerFlatChaos,            0.8)
  63. #define        (kPlayerFlatClumps,            1)
  64. #define        (kPlayerTreePercentage,            0.1)
  65.  
  66.  
  67. //////////////////////////////////////////////////////////////////////
  68. // inner neutral definitions
  69. #define        (kNeutralInnerRadius,            0.05)
  70. #define        (kNeutralOuterRadius,            0.1)
  71. #define        (kNeutralOptimalFactor,            0.7)
  72. #define        (kNumInnerNeutrals,            Between(0, 0))
  73. #define        (kInnerNeutralPercentLand,        0.0)
  74. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  75. #define        (kInnerNeutralTreePercentage,          0.15)
  76. #define        (kInnerNeutralLandChaos,        0.8)
  77. #define        (kInnerNeutralLandClumps,        1)
  78. #define        (kInnerNeutralFlatChaos,        0.8)
  79. #define        (kInnerNeutralFlatClumps,        2)
  80.  
  81.  
  82. //////////////////////////////////////////////////////////////////////
  83. // outer neutral definitions
  84. #define        (kNumOuterNeutrals,            Between(0, 0))
  85. #define        (kOuterNeutralPercentLand,        0.4)
  86. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  87. #define        (kOuterNeutralTreePercentage,          0.09)
  88. #define        (kOuterNeutralLandChaos,        0.8)
  89. #define        (kOuterNeutralLandClumps,        1)
  90. #define        (kOuterNeutralFlatChaos,        0.8)
  91. #define        (kOuterNeutralFlatClumps,        2)
  92.  
  93.  
  94. //////////////////////////////////////////////////////////////////////
  95. // resource definitions
  96. #define        (kMaxResourceElevation,            2)
  97. #define        (kResourceToEdgeDistance,        1)
  98. #define        (kResourceToWaterDistance,        1)
  99.  
  100. #define        (kAnimalPerPlayer,            0)
  101. #define        (kAnimalPerNeutral,            0)
  102.  
  103. #define        (kBerryPerPlayer,                1)
  104. #define        (kBerryPerNeutral,            0)
  105.  
  106. #define        (kFishPerPlayer,                20)
  107. #define        (kFishPerNeutral,                20)
  108.  
  109. #define        (kGoldPerPlayer,                1)
  110. #define        (kGoldPerNeutral,                0)
  111.  
  112. #define        (kOilPerPlayer,                    0)
  113. #define        (kOilPerNeutral,                0)
  114.  
  115. #define        (kSteelPerPlayer,                1)
  116. #define        (kSteelPerNeutral,                0)
  117.  
  118. #define        (kStonePerPlayer,                1)
  119. #define        (kStonePerNeutral,                0)
  120.  
  121. #define        (kTreePerPlayer,                1)
  122. #define        (kTreePerNeutral,                0)
  123.  
  124.  
  125. //////////////////////////////////////////////////////////////////////
  126. // forest definitions
  127. #define        (kForestFreeRadius,            6)
  128. #define        (kForestsPerPlayer,            2)
  129. #define        (kForestChaosLevel,            1)
  130. #define        (kMaxClumpsPerForest,            1)
  131.  
  132.  
  133. #elif Is3Players
  134. //////////////////////////////////////////////////////////////////////
  135. // 3 PLAYERS...
  136. //////////////////////////////////////////////////////////////////////
  137.  
  138. PlaceWorldUnitInRing (Res-GoldMine, 10, 12)
  139. PlaceWorldUnitInRing (Res-Iron, 10, 12)
  140.  
  141. //////////////////////////////////////////////////////////////////////
  142. // terrain definitions
  143. #define        (kMinIntElevation,                -8)
  144. #define        (kMaxIntElevation,                8)
  145. #define        (kElevationScale,                      1)
  146. #define        (kPercentLand,                    Between(0.39, 0.39))
  147. #define        (kWaterBorder,                    0)
  148. #define        (kRiverWidth,                    8)
  149. #define        (kCoastToDeepWaterPercentage                  1.0)
  150. #define        (kHeightMapChaos,                    Between(15, 15))
  151.         
  152. #define        (kMinimumStartPositionToMapEdge        0)
  153. #define        (kOuterPushFromMapCenter            14)
  154. #define        (kInnerPushFromMapCenter             0)                                    
  155.  
  156. //////////////////////////////////////////////////////////////////////
  157. // player definitions
  158. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  159. #define        (kPlayerInnerRadius,            0.5)
  160. #define        (kPlayerOuterRadius,            0.9)
  161. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  162. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  163. #define        (kPlayerLandChaos,            1)
  164. #define        (kPlayerLandClumps,            1)
  165. #define        (kPlayerFlatChaos,            0.8)
  166. #define        (kPlayerFlatClumps,            1)
  167. #define        (kPlayerTreePercentage,            0.1)
  168.  
  169.  
  170. //////////////////////////////////////////////////////////////////////
  171. // inner neutral definitions
  172. #define        (kNeutralInnerRadius,            0.05)
  173. #define        (kNeutralOuterRadius,            0.1)
  174. #define        (kNeutralOptimalFactor,            0.7)
  175. #define        (kNumInnerNeutrals,            Between(0, 0))
  176. #define        (kInnerNeutralPercentLand,        0.0)
  177. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  178. #define        (kInnerNeutralTreePercentage,          0.15)
  179. #define        (kInnerNeutralLandChaos,        0.8)
  180. #define        (kInnerNeutralLandClumps,        1)
  181. #define        (kInnerNeutralFlatChaos,        0.8)
  182. #define        (kInnerNeutralFlatClumps,        2)
  183.  
  184.  
  185. //////////////////////////////////////////////////////////////////////
  186. // outer neutral definitions
  187. #define        (kNumOuterNeutrals,            Between(0, 0))
  188. #define        (kOuterNeutralPercentLand,        0.4)
  189. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  190. #define        (kOuterNeutralTreePercentage,          0.09)
  191. #define        (kOuterNeutralLandChaos,        0.8)
  192. #define        (kOuterNeutralLandClumps,        1)
  193. #define        (kOuterNeutralFlatChaos,        0.8)
  194. #define        (kOuterNeutralFlatClumps,        2)
  195.  
  196.  
  197. //////////////////////////////////////////////////////////////////////
  198. // resource definitions
  199. #define        (kMaxResourceElevation,            2)
  200. #define        (kResourceToEdgeDistance,        1)
  201. #define        (kResourceToWaterDistance,        1)
  202.  
  203. #define        (kAnimalPerPlayer,            0)
  204. #define        (kAnimalPerNeutral,            0)
  205.  
  206. #define        (kBerryPerPlayer,                1)
  207. #define        (kBerryPerNeutral,                0)
  208.  
  209. #define        (kFishPerPlayer,                18)
  210. #define        (kFishPerNeutral,                20)
  211.  
  212. #define        (kGoldPerPlayer,                1)
  213. #define        (kGoldPerNeutral,                0)
  214.  
  215. #define        (kOilPerPlayer,                    0)
  216. #define        (kOilPerNeutral,                0)
  217.  
  218. #define        (kSteelPerPlayer,                1)
  219. #define        (kSteelPerNeutral,                0)
  220.  
  221. #define        (kStonePerPlayer,                1)
  222. #define        (kStonePerNeutral,                0)
  223.  
  224. #define        (kTreePerPlayer,                1)
  225. #define        (kTreePerNeutral,                0)
  226.  
  227.  
  228. //////////////////////////////////////////////////////////////////////
  229. // forest definitions
  230. #define        (kForestFreeRadius,            6)
  231. #define        (kForestsPerPlayer,            2)
  232. #define        (kForestChaosLevel,            1)
  233. #define        (kMaxClumpsPerForest,            1)
  234.  
  235.  
  236. #elif Is4Players
  237. //////////////////////////////////////////////////////////////////////
  238. // 4 PLAYERS...
  239. //////////////////////////////////////////////////////////////////////
  240.  
  241. //////////////////////////////////////////////////////////////////////
  242. // terrain definitions
  243. #define        (kMinIntElevation,                -8)
  244. #define        (kMaxIntElevation,                8)
  245. #define        (kElevationScale,                      1)
  246. #define        (kPercentLand,                    Between(0.4, 0.4))
  247. #define        (kWaterBorder,                    0)
  248. #define        (kRiverWidth,                    8)
  249. #define        (kCoastToDeepWaterPercentage                  1.0)
  250. #define        (kHeightMapChaos,                    Between(15, 15))
  251.         
  252. #define        (kMinimumStartPositionToMapEdge        0)
  253. #define        (kOuterPushFromMapCenter            14)
  254. #define        (kInnerPushFromMapCenter             0)                                    
  255.  
  256. //////////////////////////////////////////////////////////////////////
  257. // player definitions
  258. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  259. #define        (kPlayerInnerRadius,            0.5)
  260. #define        (kPlayerOuterRadius,            0.9)
  261. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  262. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  263. #define        (kPlayerLandChaos,            1)
  264. #define        (kPlayerLandClumps,            1)
  265. #define        (kPlayerFlatChaos,            0.8)
  266. #define        (kPlayerFlatClumps,            1)
  267. #define        (kPlayerTreePercentage,            0.1)
  268.  
  269.  
  270. //////////////////////////////////////////////////////////////////////
  271. // inner neutral definitions
  272. #define        (kNeutralInnerRadius,            0.05)
  273. #define        (kNeutralOuterRadius,            0.1)
  274. #define        (kNeutralOptimalFactor,            0.7)
  275. #define        (kNumInnerNeutrals,            Between(0, 0))
  276. #define        (kInnerNeutralPercentLand,        0.0)
  277. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  278. #define        (kInnerNeutralTreePercentage,          0.15)
  279. #define        (kInnerNeutralLandChaos,        0.8)
  280. #define        (kInnerNeutralLandClumps,        1)
  281. #define        (kInnerNeutralFlatChaos,        0.8)
  282. #define        (kInnerNeutralFlatClumps,        2)
  283.  
  284.  
  285. //////////////////////////////////////////////////////////////////////
  286. // outer neutral definitions
  287. #define        (kNumOuterNeutrals,            Between(0, 0))
  288. #define        (kOuterNeutralPercentLand,        0.4)
  289. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  290. #define        (kOuterNeutralTreePercentage,          0.09)
  291. #define        (kOuterNeutralLandChaos,        0.8)
  292. #define        (kOuterNeutralLandClumps,        1)
  293. #define        (kOuterNeutralFlatChaos,        0.8)
  294. #define        (kOuterNeutralFlatClumps,        2)
  295.  
  296.  
  297. //////////////////////////////////////////////////////////////////////
  298. // resource definitions
  299. #define        (kMaxResourceElevation,            2)
  300. #define        (kResourceToEdgeDistance,        1)
  301. #define        (kResourceToWaterDistance,        1)
  302.  
  303. #define        (kAnimalPerPlayer,            0)
  304. #define        (kAnimalPerNeutral,            0)
  305.  
  306. #define        (kBerryPerPlayer,                1)
  307. #define        (kBerryPerNeutral,                0)
  308.  
  309. #define        (kFishPerPlayer,                15)
  310. #define        (kFishPerNeutral,                20)
  311.  
  312. #define        (kGoldPerPlayer,                1)
  313. #define        (kGoldPerNeutral,                0)
  314.  
  315. #define        (kOilPerPlayer,                    0)
  316. #define        (kOilPerNeutral,                0)
  317.  
  318. #define        (kSteelPerPlayer,                1)
  319. #define        (kSteelPerNeutral,                0)
  320.  
  321. #define        (kStonePerPlayer,                1)
  322. #define        (kStonePerNeutral,                0)
  323.  
  324. #define        (kTreePerPlayer,                1)
  325. #define        (kTreePerNeutral,                0)
  326.  
  327.  
  328. //////////////////////////////////////////////////////////////////////
  329. // forest definitions
  330. #define        (kForestFreeRadius,            5)
  331. #define        (kForestsPerPlayer,            2)
  332. #define        (kForestChaosLevel,            1)
  333. #define        (kMaxClumpsPerForest,            1)
  334.  
  335. #elif Is5Players
  336. //////////////////////////////////////////////////////////////////////
  337. // 5 PLAYERS...
  338. //////////////////////////////////////////////////////////////////////
  339.  
  340. PlaceWorldUnitInRing (Res-GoldMine, 12, 15)
  341. PlaceWorldUnitInRing (Res-Iron, 12, 15)
  342.  
  343. //////////////////////////////////////////////////////////////////////
  344. // terrain definitions
  345. #define        (kMinIntElevation,                -8)
  346. #define        (kMaxIntElevation,                8)
  347. #define        (kElevationScale,                      1)
  348. #define        (kPercentLand,                    Between(0.34, 0.34))
  349. #define        (kWaterBorder,                    0)
  350. #define        (kRiverWidth,                    8)
  351. #define        (kCoastToDeepWaterPercentage                  1.0)
  352. #define        (kHeightMapChaos,                    Between(15, 15))
  353.         
  354. #define        (kMinimumStartPositionToMapEdge            0)
  355. #define        (kOuterPushFromMapCenter            14)
  356. #define        (kInnerPushFromMapCenter             0)                                    
  357.  
  358. //////////////////////////////////////////////////////////////////////
  359. // player definitions
  360. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  361. #define        (kPlayerInnerRadius,            0.5)
  362. #define        (kPlayerOuterRadius,            0.9)
  363. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  364. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  365. #define        (kPlayerLandChaos,            1)
  366. #define        (kPlayerLandClumps,            1)
  367. #define        (kPlayerFlatChaos,            0.8)
  368. #define        (kPlayerFlatClumps,            1)
  369. #define        (kPlayerTreePercentage,            0.1)
  370.  
  371.  
  372. //////////////////////////////////////////////////////////////////////
  373. // inner neutral definitions
  374. #define        (kNeutralInnerRadius,            0.05)
  375. #define        (kNeutralOuterRadius,            0.1)
  376. #define        (kNeutralOptimalFactor,            0.7)
  377. #define        (kNumInnerNeutrals,            Between(0, 0))
  378. #define        (kInnerNeutralPercentLand,        0.0)
  379. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  380. #define        (kInnerNeutralTreePercentage,          0.15)
  381. #define        (kInnerNeutralLandChaos,        0.8)
  382. #define        (kInnerNeutralLandClumps,        1)
  383. #define        (kInnerNeutralFlatChaos,        0.8)
  384. #define        (kInnerNeutralFlatClumps,        2)
  385.  
  386.  
  387. //////////////////////////////////////////////////////////////////////
  388. // outer neutral definitions
  389. #define        (kNumOuterNeutrals,            Between(0, 0))
  390. #define        (kOuterNeutralPercentLand,        0.4)
  391. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  392. #define        (kOuterNeutralTreePercentage,          0.09)
  393. #define        (kOuterNeutralLandChaos,        0.8)
  394. #define        (kOuterNeutralLandClumps,        1)
  395. #define        (kOuterNeutralFlatChaos,        0.8)
  396. #define        (kOuterNeutralFlatClumps,        2)
  397.  
  398.  
  399. //////////////////////////////////////////////////////////////////////
  400. // resource definitions
  401. #define        (kMaxResourceElevation,            2)
  402. #define        (kResourceToEdgeDistance,        1)
  403. #define        (kResourceToWaterDistance,        1)
  404.  
  405. #define        (kAnimalPerPlayer,            0)
  406. #define        (kAnimalPerNeutral,            0)
  407.  
  408. #define        (kBerryPerPlayer,                1)
  409. #define        (kBerryPerNeutral,                0)
  410.  
  411. #define        (kFishPerPlayer,                10)
  412. #define        (kFishPerNeutral,                20)
  413.  
  414. #define        (kGoldPerPlayer,                1)
  415. #define        (kGoldPerNeutral,                0)
  416.  
  417. #define        (kOilPerPlayer,                    0)
  418. #define        (kOilPerNeutral,                0)
  419.  
  420. #define        (kSteelPerPlayer,                1)
  421. #define        (kSteelPerNeutral,                0)
  422.  
  423. #define        (kStonePerPlayer,                1)
  424. #define        (kStonePerNeutral,                0)
  425.  
  426. #define        (kTreePerPlayer,                1)
  427. #define        (kTreePerNeutral,                0)
  428.  
  429.  
  430. //////////////////////////////////////////////////////////////////////
  431. // forest definitions
  432. #define        (kForestFreeRadius,            5)
  433. #define        (kForestsPerPlayer,            2)
  434. #define        (kForestChaosLevel,            1)
  435. #define        (kMaxClumpsPerForest,            1)
  436.  
  437. #elif Is6Players
  438. //////////////////////////////////////////////////////////////////////
  439. // 6 PLAYERS...
  440. //////////////////////////////////////////////////////////////////////
  441.  
  442. //////////////////////////////////////////////////////////////////////
  443. // terrain definitions
  444. #define        (kMinIntElevation,                -8)
  445. #define        (kMaxIntElevation,                8)
  446. #define        (kElevationScale,                      1)
  447. #define        (kPercentLand,                    Between(0.58, 0.58))
  448. #define        (kWaterBorder,                    0)
  449. #define        (kRiverWidth,                    8)
  450. #define        (kCoastToDeepWaterPercentage                  1.0)
  451. #define        (kHeightMapChaos,                    Between(15, 15))
  452.         
  453. #define        (kMinimumStartPositionToMapEdge            0)
  454. #define        (kOuterPushFromMapCenter            14)
  455. #define        (kInnerPushFromMapCenter             0)                                    
  456.  
  457. //////////////////////////////////////////////////////////////////////
  458. // player definitions
  459. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  460. #define        (kPlayerInnerRadius,            0.5)
  461. #define        (kPlayerOuterRadius,            0.9)
  462. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  463. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  464. #define        (kPlayerLandChaos,            1)
  465. #define        (kPlayerLandClumps,            1)
  466. #define        (kPlayerFlatChaos,            0.8)
  467. #define        (kPlayerFlatClumps,            1)
  468. #define        (kPlayerTreePercentage,            0.1)
  469.  
  470.  
  471. //////////////////////////////////////////////////////////////////////
  472. // inner neutral definitions
  473. #define        (kNeutralInnerRadius,            0.05)
  474. #define        (kNeutralOuterRadius,            0.1)
  475. #define        (kNeutralOptimalFactor,            0.7)
  476. #define        (kNumInnerNeutrals,            Between(0, 0))
  477. #define        (kInnerNeutralPercentLand,        0.0)
  478. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  479. #define        (kInnerNeutralTreePercentage,          0.15)
  480. #define        (kInnerNeutralLandChaos,        0.8)
  481. #define        (kInnerNeutralLandClumps,        1)
  482. #define        (kInnerNeutralFlatChaos,        0.8)
  483. #define        (kInnerNeutralFlatClumps,        2)
  484.  
  485.  
  486. //////////////////////////////////////////////////////////////////////
  487. // outer neutral definitions
  488. #define        (kNumOuterNeutrals,            Between(0, 0))
  489. #define        (kOuterNeutralPercentLand,        0.4)
  490. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  491. #define        (kOuterNeutralTreePercentage,          0.09)
  492. #define        (kOuterNeutralLandChaos,        0.8)
  493. #define        (kOuterNeutralLandClumps,        1)
  494. #define        (kOuterNeutralFlatChaos,        0.8)
  495. #define        (kOuterNeutralFlatClumps,        2)
  496.  
  497.  
  498. //////////////////////////////////////////////////////////////////////
  499. // resource definitions
  500. #define        (kMaxResourceElevation,            2)
  501. #define        (kResourceToEdgeDistance,        1)
  502. #define        (kResourceToWaterDistance,        1)
  503.  
  504. #define        (kAnimalPerPlayer,            0)
  505. #define        (kAnimalPerNeutral,            0)
  506.  
  507. #define        (kBerryPerPlayer,                1)
  508. #define        (kBerryPerNeutral,                0)
  509.  
  510. #define        (kFishPerPlayer,                10)
  511. #define        (kFishPerNeutral,                20)
  512.  
  513. #define        (kGoldPerPlayer,                1)
  514. #define        (kGoldPerNeutral,                0)
  515.  
  516. #define        (kOilPerPlayer,                    0)
  517. #define        (kOilPerNeutral,                0)
  518.  
  519. #define        (kSteelPerPlayer,                1)
  520. #define        (kSteelPerNeutral,                0)
  521.  
  522. #define        (kStonePerPlayer,                1)
  523. #define        (kStonePerNeutral,                0)
  524.  
  525. #define        (kTreePerPlayer,                1)
  526. #define        (kTreePerNeutral,                0)
  527.  
  528.  
  529. //////////////////////////////////////////////////////////////////////
  530. // forest definitions
  531. #define        (kForestFreeRadius,            5)
  532. #define        (kForestsPerPlayer,            2)
  533. #define        (kForestChaosLevel,            1)
  534. #define        (kMaxClumpsPerForest,            1)
  535.  
  536. #elif Is7Players
  537. //////////////////////////////////////////////////////////////////////
  538. // 7 PLAYERS...
  539. //////////////////////////////////////////////////////////////////////
  540.  
  541. //////////////////////////////////////////////////////////////////////
  542. // terrain definitions
  543. #define        (kMinIntElevation,                -8)
  544. #define        (kMaxIntElevation,                8)
  545. #define        (kElevationScale,                      1)
  546. #define        (kPercentLand,                    Between(0.60, 0.60))
  547. #define        (kWaterBorder,                    0)
  548. #define        (kRiverWidth,                    8)
  549. #define        (kCoastToDeepWaterPercentage                  1.0)
  550. #define        (kHeightMapChaos,                    Between(15, 15))
  551.         
  552. #define        (kMinimumStartPositionToMapEdge            0)
  553. #define        (kOuterPushFromMapCenter            14)
  554. #define        (kInnerPushFromMapCenter             0)                                    
  555.  
  556. //////////////////////////////////////////////////////////////////////
  557. // player definitions
  558. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  559. #define        (kPlayerInnerRadius,            0.5)
  560. #define        (kPlayerOuterRadius,            0.9)
  561. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  562. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  563. #define        (kPlayerLandChaos,            1)
  564. #define        (kPlayerLandClumps,            1)
  565. #define        (kPlayerFlatChaos,            0.8)
  566. #define        (kPlayerFlatClumps,            1)
  567. #define        (kPlayerTreePercentage,            0.1)
  568.  
  569.  
  570. //////////////////////////////////////////////////////////////////////
  571. // inner neutral definitions
  572. #define        (kNeutralInnerRadius,            0.05)
  573. #define        (kNeutralOuterRadius,            0.1)
  574. #define        (kNeutralOptimalFactor,            0.7)
  575. #define        (kNumInnerNeutrals,            Between(0, 0))
  576. #define        (kInnerNeutralPercentLand,        0.0)
  577. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  578. #define        (kInnerNeutralTreePercentage,          0.15)
  579. #define        (kInnerNeutralLandChaos,        0.8)
  580. #define        (kInnerNeutralLandClumps,        1)
  581. #define        (kInnerNeutralFlatChaos,        0.8)
  582. #define        (kInnerNeutralFlatClumps,        2)
  583.  
  584.  
  585. //////////////////////////////////////////////////////////////////////
  586. // outer neutral definitions
  587. #define        (kNumOuterNeutrals,            Between(0, 0))
  588. #define        (kOuterNeutralPercentLand,        0.4)
  589. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  590. #define        (kOuterNeutralTreePercentage,          0.09)
  591. #define        (kOuterNeutralLandChaos,        0.8)
  592. #define        (kOuterNeutralLandClumps,        1)
  593. #define        (kOuterNeutralFlatChaos,        0.8)
  594. #define        (kOuterNeutralFlatClumps,        2)
  595.  
  596.  
  597. //////////////////////////////////////////////////////////////////////
  598. // resource definitions
  599. #define        (kMaxResourceElevation,            2)
  600. #define        (kResourceToEdgeDistance,        1)
  601. #define        (kResourceToWaterDistance,        1)
  602.  
  603. #define        (kAnimalPerPlayer,            0)
  604. #define        (kAnimalPerNeutral,            0)
  605.  
  606. #define        (kBerryPerPlayer,                1)
  607. #define        (kBerryPerNeutral,                0)
  608.  
  609. #define        (kFishPerPlayer,                10)
  610. #define        (kFishPerNeutral,                20)
  611.  
  612. #define        (kGoldPerPlayer,                1)
  613. #define        (kGoldPerNeutral,                0)
  614.  
  615. #define        (kOilPerPlayer,                    0)
  616. #define        (kOilPerNeutral,                0)
  617.  
  618. #define        (kSteelPerPlayer,                1)
  619. #define        (kSteelPerNeutral,                0)
  620.  
  621. #define        (kStonePerPlayer,                1)
  622. #define        (kStonePerNeutral,                0)
  623.  
  624. #define        (kTreePerPlayer,                1)
  625. #define        (kTreePerNeutral,                0)
  626.  
  627.  
  628. //////////////////////////////////////////////////////////////////////
  629. // forest definitions
  630. #define        (kForestFreeRadius,            5)
  631. #define        (kForestsPerPlayer,            2)
  632. #define        (kForestChaosLevel,            1)
  633. #define        (kMaxClumpsPerForest,            1)
  634.  
  635. #elif Is8Players
  636. //////////////////////////////////////////////////////////////////////
  637. // 8 PLAYERS...
  638. //////////////////////////////////////////////////////////////////////
  639.  
  640. //////////////////////////////////////////////////////////////////////
  641. // terrain definitions
  642. #define        (kMinIntElevation,                -8)
  643. #define        (kMaxIntElevation,                8)
  644. #define        (kElevationScale,                      1)
  645. #define        (kPercentLand,                    Between(0.65, 0.65))
  646. #define        (kWaterBorder,                    0)
  647. #define        (kRiverWidth,                    8)
  648. #define        (kCoastToDeepWaterPercentage                  1.0)
  649. #define        (kHeightMapChaos,                    Between(15, 15))
  650.         
  651. #define        (kMinimumStartPositionToMapEdge            0)
  652. #define        (kOuterPushFromMapCenter            14)
  653. #define        (kInnerPushFromMapCenter             0)                                    
  654.  
  655. //////////////////////////////////////////////////////////////////////
  656. // player definitions
  657. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  658. #define        (kPlayerInnerRadius,            0.5)
  659. #define        (kPlayerOuterRadius,            0.9)
  660. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  661. #define        (kPlayerPercentFlat,            Between(0.85, 0.85))
  662. #define        (kPlayerLandChaos,            1)
  663. #define        (kPlayerLandClumps,            1)
  664. #define        (kPlayerFlatChaos,            0.8)
  665. #define        (kPlayerFlatClumps,            1)
  666. #define        (kPlayerTreePercentage,            0.1)
  667.  
  668.  
  669. //////////////////////////////////////////////////////////////////////
  670. // inner neutral definitions
  671. #define        (kNeutralInnerRadius,            0.05)
  672. #define        (kNeutralOuterRadius,            0.1)
  673. #define        (kNeutralOptimalFactor,            0.7)
  674. #define        (kNumInnerNeutrals,            Between(0, 0))
  675. #define        (kInnerNeutralPercentLand,        0.0)
  676. #define        (kInnerNeutralPercentFlat,        Between(1, 1))
  677. #define        (kInnerNeutralTreePercentage,          0.15)
  678. #define        (kInnerNeutralLandChaos,        0.8)
  679. #define        (kInnerNeutralLandClumps,        1)
  680. #define        (kInnerNeutralFlatChaos,        0.8)
  681. #define        (kInnerNeutralFlatClumps,        2)
  682.  
  683.  
  684. //////////////////////////////////////////////////////////////////////
  685. // outer neutral definitions
  686. #define        (kNumOuterNeutrals,            Between(0, 0))
  687. #define        (kOuterNeutralPercentLand,        0.4)
  688. #define        (kOuterNeutralPercentFlat,        Between(.8, .8))
  689. #define        (kOuterNeutralTreePercentage,          0.09)
  690. #define        (kOuterNeutralLandChaos,        0.8)
  691. #define        (kOuterNeutralLandClumps,        1)
  692. #define        (kOuterNeutralFlatChaos,        0.8)
  693. #define        (kOuterNeutralFlatClumps,        2)
  694.  
  695.  
  696. //////////////////////////////////////////////////////////////////////
  697. // resource definitions
  698. #define        (kMaxResourceElevation,            2)
  699. #define        (kResourceToEdgeDistance,        1)
  700. #define        (kResourceToWaterDistance,        1)
  701.  
  702. #define        (kAnimalPerPlayer,            0)
  703. #define        (kAnimalPerNeutral,            0)
  704.  
  705. #define        (kBerryPerPlayer,                1)
  706. #define        (kBerryPerNeutral,                0)
  707.  
  708. #define        (kFishPerPlayer,                10)
  709. #define        (kFishPerNeutral,                20)
  710.  
  711. #define        (kGoldPerPlayer,                1)
  712. #define        (kGoldPerNeutral,                0)
  713.  
  714. #define        (kOilPerPlayer,                    0)
  715. #define        (kOilPerNeutral,                0)
  716.  
  717. #define        (kSteelPerPlayer,                1)
  718. #define        (kSteelPerNeutral,                0)
  719.  
  720. #define        (kStonePerPlayer,                1)
  721. #define        (kStonePerNeutral,                0)
  722.  
  723. #define        (kTreePerPlayer,                1)
  724. #define        (kTreePerNeutral,                0)
  725.  
  726.  
  727. //////////////////////////////////////////////////////////////////////
  728. // forest definitions
  729. #define        (kForestFreeRadius,            5)
  730. #define        (kForestsPerPlayer,            2)
  731. #define        (kForestChaosLevel,            1)
  732. #define        (kMaxClumpsPerForest,            1)
  733.  
  734. #elif Is9Players
  735. //////////////////////////////////////////////////////////////////////
  736. // 9 PLAYERS...
  737. //////////////////////////////////////////////////////////////////////
  738.  
  739. //////////////////////////////////////////////////////////////////////
  740. // terrain definitions
  741. #define        (kMinIntElevation,                -10)
  742. #define        (kMaxIntElevation,                12)
  743. #define        (kElevationScale,                      1)
  744. #define        (kPercentLand,                    Between(0.59, 0.59))
  745. #define        (kWaterBorder,                    0)
  746. #define        (kRiverWidth,                    8)
  747. #define        (kCoastToDeepWaterPercentage                1.0)
  748. #define        (kHeightMapChaos,                    Between(6, 15))
  749.         
  750. #define        (kMinimumStartPositionToMapEdge        0)
  751. #define        (kOuterPushFromMapCenter            13)
  752. #define        (kInnerPushFromMapCenter             0)
  753.  
  754. //////////////////////////////////////////////////////////////////////
  755. // player definitions
  756. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  757. #define        (kPlayerInnerRadius,            0.01)
  758. #define        (kPlayerOuterRadius,            0.9)
  759. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  760. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  761. #define        (kPlayerLandChaos,            0.8)
  762. #define        (kPlayerLandClumps,            1)
  763. #define        (kPlayerFlatChaos,            0.8)
  764. #define        (kPlayerFlatClumps,            2)
  765. #define        (kPlayerTreePercentage,            0.04)
  766.  
  767.  
  768. //////////////////////////////////////////////////////////////////////
  769. // inner neutral definitions
  770. #define        (kNeutralInnerRadius,            0.05)
  771. #define        (kNeutralOuterRadius,            0.4)
  772. #define        (kNeutralOptimalFactor,            0.7)
  773. #define        (kNumInnerNeutrals,            Between(0, 0))
  774. #define        (kInnerNeutralPercentLand,        0.35)
  775. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  776. #define        (kInnerNeutralTreePercentage,          0.04)
  777. #define        (kInnerNeutralLandChaos,        0.8)
  778. #define        (kInnerNeutralLandClumps,        1)
  779. #define        (kInnerNeutralFlatChaos,        0.8)
  780. #define        (kInnerNeutralFlatClumps,        2)
  781.  
  782.  
  783. //////////////////////////////////////////////////////////////////////
  784. // outer neutral definitions
  785. #define        (kNumOuterNeutrals,            Between(0, 0))
  786. #define        (kOuterNeutralPercentLand,        0.35)
  787. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  788. #define        (kOuterNeutralTreePercentage,          0.04)
  789. #define        (kOuterNeutralLandChaos,        0.8)
  790. #define        (kOuterNeutralLandClumps,        1)
  791. #define        (kOuterNeutralFlatChaos,        0.8)
  792. #define        (kOuterNeutralFlatClumps,        2)
  793.  
  794.  
  795. //////////////////////////////////////////////////////////////////////
  796. // resource definitions
  797. #define        (kMaxResourceElevation,            2)
  798. #define        (kResourceToEdgeDistance,        2)
  799. #define        (kResourceToWaterDistance,        2)
  800.  
  801. #define        (kAnimalPerPlayer,            0)
  802. #define        (kAnimalPerNeutral,            0)
  803.  
  804. #define        (kBerryPerPlayer,                0)
  805. #define        (kBerryPerNeutral,            0)
  806.  
  807. #define        (kFishPerPlayer,                10)
  808. #define        (kFishPerNeutral,                0)
  809.  
  810. #define        (kGoldPerPlayer,                1)
  811. #define        (kGoldPerNeutral,                0)
  812.  
  813. #define        (kOilPerPlayer,                0)
  814. #define        (kOilPerNeutral,                0)
  815.  
  816. #define        (kSteelPerPlayer,                1)
  817. #define        (kSteelPerNeutral,            0)
  818.  
  819. #define        (kStonePerPlayer,                1)
  820. #define        (kStonePerNeutral,            0)
  821.  
  822. #define        (kTreePerPlayer,                0)
  823. #define        (kTreePerNeutral,                0)
  824.  
  825. //////////////////////////////////////////////////////////////////////
  826. // forest definitions
  827. #define        (kForestFreeRadius,            3)
  828. #define        (kForestsPerPlayer,            3)
  829. #define        (kForestChaosLevel,            0.1)
  830. #define        (kMaxClumpsPerForest,            2)
  831.  
  832.  
  833. #elif Is10Players
  834. //////////////////////////////////////////////////////////////////////
  835. // 10 PLAYERS...
  836. //////////////////////////////////////////////////////////////////////
  837.  
  838. //////////////////////////////////////////////////////////////////////
  839. // terrain definitions
  840. #define        (kMinIntElevation,                -10)
  841. #define        (kMaxIntElevation,                12)
  842. #define        (kElevationScale,                      1)
  843. #define        (kPercentLand,                    Between(0.58, 0.58))
  844. #define        (kWaterBorder,                    0)
  845. #define        (kRiverWidth,                    7)
  846. #define        (kCoastToDeepWaterPercentage                1.0)
  847. #define        (kHeightMapChaos,                    Between(6, 15))
  848.         
  849. #define        (kMinimumStartPositionToMapEdge        0)
  850. #define        (kOuterPushFromMapCenter            12)
  851. #define        (kInnerPushFromMapCenter             0)
  852.  
  853. //////////////////////////////////////////////////////////////////////
  854. // player definitions
  855. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  856. #define        (kPlayerInnerRadius,            0.01)
  857. #define        (kPlayerOuterRadius,            0.9)
  858. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  859. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  860. #define        (kPlayerLandChaos,            0.8)
  861. #define        (kPlayerLandClumps,            1)
  862. #define        (kPlayerFlatChaos,            0.8)
  863. #define        (kPlayerFlatClumps,            2)
  864. #define        (kPlayerTreePercentage,            0.04)
  865.  
  866.  
  867. //////////////////////////////////////////////////////////////////////
  868. // inner neutral definitions
  869. #define        (kNeutralInnerRadius,            0.05)
  870. #define        (kNeutralOuterRadius,            0.4)
  871. #define        (kNeutralOptimalFactor,            0.7)
  872. #define        (kNumInnerNeutrals,            Between(0, 0))
  873. #define        (kInnerNeutralPercentLand,        0.35)
  874. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  875. #define        (kInnerNeutralTreePercentage,          0.04)
  876. #define        (kInnerNeutralLandChaos,        0.8)
  877. #define        (kInnerNeutralLandClumps,        1)
  878. #define        (kInnerNeutralFlatChaos,        0.8)
  879. #define        (kInnerNeutralFlatClumps,        2)
  880.  
  881.  
  882. //////////////////////////////////////////////////////////////////////
  883. // outer neutral definitions
  884. #define        (kNumOuterNeutrals,            Between(0, 0))
  885. #define        (kOuterNeutralPercentLand,        0.35)
  886. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  887. #define        (kOuterNeutralTreePercentage,          0.04)
  888. #define        (kOuterNeutralLandChaos,        0.8)
  889. #define        (kOuterNeutralLandClumps,        1)
  890. #define        (kOuterNeutralFlatChaos,        0.8)
  891. #define        (kOuterNeutralFlatClumps,        2)
  892.  
  893.  
  894. //////////////////////////////////////////////////////////////////////
  895. // resource definitions
  896. #define        (kMaxResourceElevation,            2)
  897. #define        (kResourceToEdgeDistance,        2)
  898. #define        (kResourceToWaterDistance,        2)
  899.  
  900. #define        (kAnimalPerPlayer,            0)
  901. #define        (kAnimalPerNeutral,            0)
  902.  
  903. #define        (kBerryPerPlayer,                0)
  904. #define        (kBerryPerNeutral,            0)
  905.  
  906. #define        (kFishPerPlayer,                9)
  907. #define        (kFishPerNeutral,                0)
  908.  
  909. #define        (kGoldPerPlayer,                1)
  910. #define        (kGoldPerNeutral,                0)
  911.  
  912. #define        (kOilPerPlayer,                0)
  913. #define        (kOilPerNeutral,                0)
  914.  
  915. #define        (kSteelPerPlayer,                1)
  916. #define        (kSteelPerNeutral,            0)
  917.  
  918. #define        (kStonePerPlayer,                1)
  919. #define        (kStonePerNeutral,            0)
  920.  
  921. #define        (kTreePerPlayer,                0)
  922. #define        (kTreePerNeutral,                0)
  923.  
  924. //////////////////////////////////////////////////////////////////////
  925. // forest definitions
  926. #define        (kForestFreeRadius,            3)
  927. #define        (kForestsPerPlayer,            3)
  928. #define        (kForestChaosLevel,            0.1)
  929. #define        (kMaxClumpsPerForest,            2)
  930.  
  931.  
  932. #elif Is11Players
  933. //////////////////////////////////////////////////////////////////////
  934. // 11 PLAYERS...
  935. //////////////////////////////////////////////////////////////////////
  936.  
  937. //////////////////////////////////////////////////////////////////////
  938. // terrain definitions
  939. #define        (kMinIntElevation,                -10)
  940. #define        (kMaxIntElevation,                12)
  941. #define        (kElevationScale,                      1)
  942. #define        (kPercentLand,                    Between(0.57, 0.57))
  943. #define        (kWaterBorder,                    0)
  944. #define        (kRiverWidth,                    7)
  945. #define        (kCoastToDeepWaterPercentage                1.0)
  946. #define        (kHeightMapChaos,                    Between(6, 15))
  947.         
  948. #define        (kMinimumStartPositionToMapEdge        0)
  949. #define        (kOuterPushFromMapCenter            12)
  950. #define        (kInnerPushFromMapCenter             0)
  951.  
  952. //////////////////////////////////////////////////////////////////////
  953. // player definitions
  954. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  955. #define        (kPlayerInnerRadius,            0.01)
  956. #define        (kPlayerOuterRadius,            0.9)
  957. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  958. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  959. #define        (kPlayerLandChaos,            0.8)
  960. #define        (kPlayerLandClumps,            1)
  961. #define        (kPlayerFlatChaos,            0.8)
  962. #define        (kPlayerFlatClumps,            2)
  963. #define        (kPlayerTreePercentage,            0.04)
  964.  
  965.  
  966. //////////////////////////////////////////////////////////////////////
  967. // inner neutral definitions
  968. #define        (kNeutralInnerRadius,            0.05)
  969. #define        (kNeutralOuterRadius,            0.4)
  970. #define        (kNeutralOptimalFactor,            0.7)
  971. #define        (kNumInnerNeutrals,            Between(0, 0))
  972. #define        (kInnerNeutralPercentLand,        0.35)
  973. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  974. #define        (kInnerNeutralTreePercentage,          0.04)
  975. #define        (kInnerNeutralLandChaos,        0.8)
  976. #define        (kInnerNeutralLandClumps,        1)
  977. #define        (kInnerNeutralFlatChaos,        0.8)
  978. #define        (kInnerNeutralFlatClumps,        2)
  979.  
  980.  
  981. //////////////////////////////////////////////////////////////////////
  982. // outer neutral definitions
  983. #define        (kNumOuterNeutrals,            Between(0, 0))
  984. #define        (kOuterNeutralPercentLand,        0.35)
  985. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  986. #define        (kOuterNeutralTreePercentage,          0.04)
  987. #define        (kOuterNeutralLandChaos,        0.8)
  988. #define        (kOuterNeutralLandClumps,        1)
  989. #define        (kOuterNeutralFlatChaos,        0.8)
  990. #define        (kOuterNeutralFlatClumps,        2)
  991.  
  992.  
  993. //////////////////////////////////////////////////////////////////////
  994. // resource definitions
  995. #define        (kMaxResourceElevation,            2)
  996. #define        (kResourceToEdgeDistance,        2)
  997. #define        (kResourceToWaterDistance,        2)
  998.  
  999. #define        (kAnimalPerPlayer,            0)
  1000. #define        (kAnimalPerNeutral,            0)
  1001.  
  1002. #define        (kBerryPerPlayer,                0)
  1003. #define        (kBerryPerNeutral,            0)
  1004.  
  1005. #define        (kFishPerPlayer,                8)
  1006. #define        (kFishPerNeutral,                0)
  1007.  
  1008. #define        (kGoldPerPlayer,                1)
  1009. #define        (kGoldPerNeutral,                0)
  1010.  
  1011. #define        (kOilPerPlayer,                0)
  1012. #define        (kOilPerNeutral,                0)
  1013.  
  1014. #define        (kSteelPerPlayer,                1)
  1015. #define        (kSteelPerNeutral,            0)
  1016.  
  1017. #define        (kStonePerPlayer,                1)
  1018. #define        (kStonePerNeutral,            0)
  1019.  
  1020. #define        (kTreePerPlayer,                0)
  1021. #define        (kTreePerNeutral,                0)
  1022.  
  1023. //////////////////////////////////////////////////////////////////////
  1024. // forest definitions
  1025. #define        (kForestFreeRadius,            3)
  1026. #define        (kForestsPerPlayer,            3)
  1027. #define        (kForestChaosLevel,            0.1)
  1028. #define        (kMaxClumpsPerForest,            2)
  1029.  
  1030.  
  1031. #elif Is12Players
  1032. //////////////////////////////////////////////////////////////////////
  1033. // 12 PLAYERS...
  1034. //////////////////////////////////////////////////////////////////////
  1035.  
  1036. //////////////////////////////////////////////////////////////////////
  1037. // terrain definitions
  1038. #define        (kMinIntElevation,                -10)
  1039. #define        (kMaxIntElevation,                12)
  1040. #define        (kElevationScale,                      1)
  1041. #define        (kPercentLand,                    Between(0.56, 0.56))
  1042. #define        (kWaterBorder,                    0)
  1043. #define        (kRiverWidth,                    7)
  1044. #define        (kCoastToDeepWaterPercentage                1.0)
  1045. #define        (kHeightMapChaos,                    Between(6, 15))
  1046.         
  1047. #define        (kMinimumStartPositionToMapEdge        0)
  1048. #define        (kOuterPushFromMapCenter            12)
  1049. #define        (kInnerPushFromMapCenter             0)
  1050.  
  1051. //////////////////////////////////////////////////////////////////////
  1052. // player definitions
  1053. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1054. #define        (kPlayerInnerRadius,            0.01)
  1055. #define        (kPlayerOuterRadius,            0.9)
  1056. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1057. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1058. #define        (kPlayerLandChaos,            0.8)
  1059. #define        (kPlayerLandClumps,            1)
  1060. #define        (kPlayerFlatChaos,            0.8)
  1061. #define        (kPlayerFlatClumps,            2)
  1062. #define        (kPlayerTreePercentage,            0.04)
  1063.  
  1064.  
  1065. //////////////////////////////////////////////////////////////////////
  1066. // inner neutral definitions
  1067. #define        (kNeutralInnerRadius,            0.05)
  1068. #define        (kNeutralOuterRadius,            0.4)
  1069. #define        (kNeutralOptimalFactor,            0.7)
  1070. #define        (kNumInnerNeutrals,            Between(0, 0))
  1071. #define        (kInnerNeutralPercentLand,        0.35)
  1072. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1073. #define        (kInnerNeutralTreePercentage,          0.04)
  1074. #define        (kInnerNeutralLandChaos,        0.8)
  1075. #define        (kInnerNeutralLandClumps,        1)
  1076. #define        (kInnerNeutralFlatChaos,        0.8)
  1077. #define        (kInnerNeutralFlatClumps,        2)
  1078.  
  1079.  
  1080. //////////////////////////////////////////////////////////////////////
  1081. // outer neutral definitions
  1082. #define        (kNumOuterNeutrals,            Between(0, 0))
  1083. #define        (kOuterNeutralPercentLand,        0.35)
  1084. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1085. #define        (kOuterNeutralTreePercentage,          0.04)
  1086. #define        (kOuterNeutralLandChaos,        0.8)
  1087. #define        (kOuterNeutralLandClumps,        1)
  1088. #define        (kOuterNeutralFlatChaos,        0.8)
  1089. #define        (kOuterNeutralFlatClumps,        2)
  1090.  
  1091.  
  1092. //////////////////////////////////////////////////////////////////////
  1093. // resource definitions
  1094. #define        (kMaxResourceElevation,            2)
  1095. #define        (kResourceToEdgeDistance,        2)
  1096. #define        (kResourceToWaterDistance,        2)
  1097.  
  1098. #define        (kAnimalPerPlayer,            0)
  1099. #define        (kAnimalPerNeutral,            0)
  1100.  
  1101. #define        (kBerryPerPlayer,                0)
  1102. #define        (kBerryPerNeutral,            0)
  1103.  
  1104. #define        (kFishPerPlayer,                8)
  1105. #define        (kFishPerNeutral,                0)
  1106.  
  1107. #define        (kGoldPerPlayer,                1)
  1108. #define        (kGoldPerNeutral,                0)
  1109.  
  1110. #define        (kOilPerPlayer,                0)
  1111. #define        (kOilPerNeutral,                0)
  1112.  
  1113. #define        (kSteelPerPlayer,                1)
  1114. #define        (kSteelPerNeutral,            0)
  1115.  
  1116. #define        (kStonePerPlayer,                1)
  1117. #define        (kStonePerNeutral,            0)
  1118.  
  1119. #define        (kTreePerPlayer,                0)
  1120. #define        (kTreePerNeutral,                0)
  1121.  
  1122. //////////////////////////////////////////////////////////////////////
  1123. // forest definitions
  1124. #define        (kForestFreeRadius,            3)
  1125. #define        (kForestsPerPlayer,            3)
  1126. #define        (kForestChaosLevel,            0.1)
  1127. #define        (kMaxClumpsPerForest,            2)
  1128.  
  1129.  
  1130. #elif Is13Players
  1131. //////////////////////////////////////////////////////////////////////
  1132. // 13 PLAYERS...
  1133. //////////////////////////////////////////////////////////////////////
  1134.  
  1135. //////////////////////////////////////////////////////////////////////
  1136. // terrain definitions
  1137. #define        (kMinIntElevation,                -10)
  1138. #define        (kMaxIntElevation,                12)
  1139. #define        (kElevationScale,                      1)
  1140. #define        (kPercentLand,                    Between(0.55, 0.55))
  1141. #define        (kWaterBorder,                    0)
  1142. #define        (kRiverWidth,                    6)
  1143. #define        (kCoastToDeepWaterPercentage                1.0)
  1144. #define        (kHeightMapChaos,                    Between(6, 15))
  1145.         
  1146. #define        (kMinimumStartPositionToMapEdge        0)
  1147. #define        (kOuterPushFromMapCenter            11)
  1148. #define        (kInnerPushFromMapCenter             0)
  1149.  
  1150. //////////////////////////////////////////////////////////////////////
  1151. // player definitions
  1152. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1153. #define        (kPlayerInnerRadius,            0.01)
  1154. #define        (kPlayerOuterRadius,            0.9)
  1155. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1156. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1157. #define        (kPlayerLandChaos,            0.8)
  1158. #define        (kPlayerLandClumps,            1)
  1159. #define        (kPlayerFlatChaos,            0.8)
  1160. #define        (kPlayerFlatClumps,            2)
  1161. #define        (kPlayerTreePercentage,            0.04)
  1162.  
  1163.  
  1164. //////////////////////////////////////////////////////////////////////
  1165. // inner neutral definitions
  1166. #define        (kNeutralInnerRadius,            0.05)
  1167. #define        (kNeutralOuterRadius,            0.4)
  1168. #define        (kNeutralOptimalFactor,            0.7)
  1169. #define        (kNumInnerNeutrals,            Between(0, 0))
  1170. #define        (kInnerNeutralPercentLand,        0.35)
  1171. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1172. #define        (kInnerNeutralTreePercentage,          0.04)
  1173. #define        (kInnerNeutralLandChaos,        0.8)
  1174. #define        (kInnerNeutralLandClumps,        1)
  1175. #define        (kInnerNeutralFlatChaos,        0.8)
  1176. #define        (kInnerNeutralFlatClumps,        2)
  1177.  
  1178.  
  1179. //////////////////////////////////////////////////////////////////////
  1180. // outer neutral definitions
  1181. #define        (kNumOuterNeutrals,            Between(0, 0))
  1182. #define        (kOuterNeutralPercentLand,        0.35)
  1183. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1184. #define        (kOuterNeutralTreePercentage,          0.04)
  1185. #define        (kOuterNeutralLandChaos,        0.8)
  1186. #define        (kOuterNeutralLandClumps,        1)
  1187. #define        (kOuterNeutralFlatChaos,        0.8)
  1188. #define        (kOuterNeutralFlatClumps,        2)
  1189.  
  1190.  
  1191. //////////////////////////////////////////////////////////////////////
  1192. // resource definitions
  1193. #define        (kMaxResourceElevation,            2)
  1194. #define        (kResourceToEdgeDistance,        2)
  1195. #define        (kResourceToWaterDistance,        2)
  1196.  
  1197. #define        (kAnimalPerPlayer,            0)
  1198. #define        (kAnimalPerNeutral,            0)
  1199.  
  1200. #define        (kBerryPerPlayer,                0)
  1201. #define        (kBerryPerNeutral,            0)
  1202.  
  1203. #define        (kFishPerPlayer,                8)
  1204. #define        (kFishPerNeutral,                0)
  1205.  
  1206. #define        (kGoldPerPlayer,                1)
  1207. #define        (kGoldPerNeutral,                0)
  1208.  
  1209. #define        (kOilPerPlayer,                0)
  1210. #define        (kOilPerNeutral,                0)
  1211.  
  1212. #define        (kSteelPerPlayer,                1)
  1213. #define        (kSteelPerNeutral,            0)
  1214.  
  1215. #define        (kStonePerPlayer,                1)
  1216. #define        (kStonePerNeutral,            0)
  1217.  
  1218. #define        (kTreePerPlayer,                0)
  1219. #define        (kTreePerNeutral,                0)
  1220.  
  1221. //////////////////////////////////////////////////////////////////////
  1222. // forest definitions
  1223. #define        (kForestFreeRadius,            3)
  1224. #define        (kForestsPerPlayer,            3)
  1225. #define        (kForestChaosLevel,            0.1)
  1226. #define        (kMaxClumpsPerForest,            2)
  1227.  
  1228.  
  1229. #elif Is14Players
  1230. //////////////////////////////////////////////////////////////////////
  1231. // 14 PLAYERS...
  1232. //////////////////////////////////////////////////////////////////////
  1233.  
  1234. //////////////////////////////////////////////////////////////////////
  1235. // terrain definitions
  1236. #define        (kMinIntElevation,                -10)
  1237. #define        (kMaxIntElevation,                12)
  1238. #define        (kElevationScale,                      1)
  1239. #define        (kPercentLand,                    Between(0.54, 0.54))
  1240. #define        (kWaterBorder,                    0)
  1241. #define        (kRiverWidth,                    6)
  1242. #define        (kCoastToDeepWaterPercentage                1.0)
  1243. #define        (kHeightMapChaos,                    Between(6, 15))
  1244.         
  1245. #define        (kMinimumStartPositionToMapEdge        0)
  1246. #define        (kOuterPushFromMapCenter            11)
  1247. #define        (kInnerPushFromMapCenter             0)
  1248.  
  1249. //////////////////////////////////////////////////////////////////////
  1250. // player definitions
  1251. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1252. #define        (kPlayerInnerRadius,            0.01)
  1253. #define        (kPlayerOuterRadius,            0.9)
  1254. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1255. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1256. #define        (kPlayerLandChaos,            0.8)
  1257. #define        (kPlayerLandClumps,            1)
  1258. #define        (kPlayerFlatChaos,            0.8)
  1259. #define        (kPlayerFlatClumps,            2)
  1260. #define        (kPlayerTreePercentage,            0.04)
  1261.  
  1262.  
  1263. //////////////////////////////////////////////////////////////////////
  1264. // inner neutral definitions
  1265. #define        (kNeutralInnerRadius,            0.05)
  1266. #define        (kNeutralOuterRadius,            0.4)
  1267. #define        (kNeutralOptimalFactor,            0.7)
  1268. #define        (kNumInnerNeutrals,            Between(0, 0))
  1269. #define        (kInnerNeutralPercentLand,        0.35)
  1270. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1271. #define        (kInnerNeutralTreePercentage,          0.04)
  1272. #define        (kInnerNeutralLandChaos,        0.8)
  1273. #define        (kInnerNeutralLandClumps,        1)
  1274. #define        (kInnerNeutralFlatChaos,        0.8)
  1275. #define        (kInnerNeutralFlatClumps,        2)
  1276.  
  1277.  
  1278. //////////////////////////////////////////////////////////////////////
  1279. // outer neutral definitions
  1280. #define        (kNumOuterNeutrals,            Between(0, 0))
  1281. #define        (kOuterNeutralPercentLand,        0.35)
  1282. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1283. #define        (kOuterNeutralTreePercentage,          0.04)
  1284. #define        (kOuterNeutralLandChaos,        0.8)
  1285. #define        (kOuterNeutralLandClumps,        1)
  1286. #define        (kOuterNeutralFlatChaos,        0.8)
  1287. #define        (kOuterNeutralFlatClumps,        2)
  1288.  
  1289.  
  1290. //////////////////////////////////////////////////////////////////////
  1291. // resource definitions
  1292. #define        (kMaxResourceElevation,            2)
  1293. #define        (kResourceToEdgeDistance,        2)
  1294. #define        (kResourceToWaterDistance,        2)
  1295.  
  1296. #define        (kAnimalPerPlayer,            0)
  1297. #define        (kAnimalPerNeutral,            0)
  1298.  
  1299. #define        (kBerryPerPlayer,                0)
  1300. #define        (kBerryPerNeutral,            0)
  1301.  
  1302. #define        (kFishPerPlayer,                8)
  1303. #define        (kFishPerNeutral,                0)
  1304.  
  1305. #define        (kGoldPerPlayer,                1)
  1306. #define        (kGoldPerNeutral,                0)
  1307.  
  1308. #define        (kOilPerPlayer,                0)
  1309. #define        (kOilPerNeutral,                0)
  1310.  
  1311. #define        (kSteelPerPlayer,                1)
  1312. #define        (kSteelPerNeutral,            0)
  1313.  
  1314. #define        (kStonePerPlayer,                1)
  1315. #define        (kStonePerNeutral,            0)
  1316.  
  1317. #define        (kTreePerPlayer,                0)
  1318. #define        (kTreePerNeutral,                0)
  1319.  
  1320. //////////////////////////////////////////////////////////////////////
  1321. // forest definitions
  1322. #define        (kForestFreeRadius,            3)
  1323. #define        (kForestsPerPlayer,            3)
  1324. #define        (kForestChaosLevel,            0.1)
  1325. #define        (kMaxClumpsPerForest,            2)
  1326.  
  1327.  
  1328. #elif Is15Players
  1329. //////////////////////////////////////////////////////////////////////
  1330. // 15 PLAYERS...
  1331. //////////////////////////////////////////////////////////////////////
  1332.  
  1333. //////////////////////////////////////////////////////////////////////
  1334. // terrain definitions
  1335. #define        (kMinIntElevation,                -10)
  1336. #define        (kMaxIntElevation,                12)
  1337. #define        (kElevationScale,                      1)
  1338. #define        (kPercentLand,                    Between(0.52, 0.52))
  1339. #define        (kWaterBorder,                    0)
  1340. #define        (kRiverWidth,                    5)
  1341. #define        (kCoastToDeepWaterPercentage                1.0)
  1342. #define        (kHeightMapChaos,                    Between(6, 15))
  1343.         
  1344. #define        (kMinimumStartPositionToMapEdge        0)
  1345. #define        (kOuterPushFromMapCenter            10)
  1346. #define        (kInnerPushFromMapCenter             0)
  1347.  
  1348. //////////////////////////////////////////////////////////////////////
  1349. // player definitions
  1350. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1351. #define        (kPlayerInnerRadius,            0.01)
  1352. #define        (kPlayerOuterRadius,            0.9)
  1353. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1354. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1355. #define        (kPlayerLandChaos,            0.8)
  1356. #define        (kPlayerLandClumps,            1)
  1357. #define        (kPlayerFlatChaos,            0.8)
  1358. #define        (kPlayerFlatClumps,            2)
  1359. #define        (kPlayerTreePercentage,            0.04)
  1360.  
  1361.  
  1362. //////////////////////////////////////////////////////////////////////
  1363. // inner neutral definitions
  1364. #define        (kNeutralInnerRadius,            0.05)
  1365. #define        (kNeutralOuterRadius,            0.4)
  1366. #define        (kNeutralOptimalFactor,            0.7)
  1367. #define        (kNumInnerNeutrals,            Between(0, 0))
  1368. #define        (kInnerNeutralPercentLand,        0.35)
  1369. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1370. #define        (kInnerNeutralTreePercentage,          0.04)
  1371. #define        (kInnerNeutralLandChaos,        0.8)
  1372. #define        (kInnerNeutralLandClumps,        1)
  1373. #define        (kInnerNeutralFlatChaos,        0.8)
  1374. #define        (kInnerNeutralFlatClumps,        2)
  1375.  
  1376.  
  1377. //////////////////////////////////////////////////////////////////////
  1378. // outer neutral definitions
  1379. #define        (kNumOuterNeutrals,            Between(0, 0))
  1380. #define        (kOuterNeutralPercentLand,        0.35)
  1381. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1382. #define        (kOuterNeutralTreePercentage,          0.04)
  1383. #define        (kOuterNeutralLandChaos,        0.8)
  1384. #define        (kOuterNeutralLandClumps,        1)
  1385. #define        (kOuterNeutralFlatChaos,        0.8)
  1386. #define        (kOuterNeutralFlatClumps,        2)
  1387.  
  1388.  
  1389. //////////////////////////////////////////////////////////////////////
  1390. // resource definitions
  1391. #define        (kMaxResourceElevation,            2)
  1392. #define        (kResourceToEdgeDistance,        2)
  1393. #define        (kResourceToWaterDistance,        2)
  1394.  
  1395. #define        (kAnimalPerPlayer,            0)
  1396. #define        (kAnimalPerNeutral,            0)
  1397.  
  1398. #define        (kBerryPerPlayer,                0)
  1399. #define        (kBerryPerNeutral,            0)
  1400.  
  1401. #define        (kFishPerPlayer,                7)
  1402. #define        (kFishPerNeutral,                0)
  1403.  
  1404. #define        (kGoldPerPlayer,                1)
  1405. #define        (kGoldPerNeutral,                0)
  1406.  
  1407. #define        (kOilPerPlayer,                0)
  1408. #define        (kOilPerNeutral,                0)
  1409.  
  1410. #define        (kSteelPerPlayer,                1)
  1411. #define        (kSteelPerNeutral,            0)
  1412.  
  1413. #define        (kStonePerPlayer,                1)
  1414. #define        (kStonePerNeutral,            0)
  1415.  
  1416. #define        (kTreePerPlayer,                0)
  1417. #define        (kTreePerNeutral,                0)
  1418.  
  1419. //////////////////////////////////////////////////////////////////////
  1420. // forest definitions
  1421. #define        (kForestFreeRadius,            3)
  1422. #define        (kForestsPerPlayer,            3)
  1423. #define        (kForestChaosLevel,            0.1)
  1424. #define        (kMaxClumpsPerForest,            2)
  1425.  
  1426.  
  1427. #elif Is16Players
  1428. //////////////////////////////////////////////////////////////////////
  1429. // 16 PLAYERS...
  1430. //////////////////////////////////////////////////////////////////////
  1431.  
  1432. //////////////////////////////////////////////////////////////////////
  1433. // terrain definitions
  1434. #define        (kMinIntElevation,                -10)
  1435. #define        (kMaxIntElevation,                12)
  1436. #define        (kElevationScale,                      1)
  1437. #define        (kPercentLand,                    Between(0.5, 0.5))
  1438. #define        (kWaterBorder,                    0)
  1439. #define        (kRiverWidth,                    5)
  1440. #define        (kCoastToDeepWaterPercentage                1.0)
  1441. #define        (kHeightMapChaos,                    Between(6, 15))
  1442.         
  1443. #define        (kMinimumStartPositionToMapEdge        0)
  1444. #define        (kOuterPushFromMapCenter            9)
  1445. #define        (kInnerPushFromMapCenter             0)
  1446.  
  1447. //////////////////////////////////////////////////////////////////////
  1448. // player definitions
  1449. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  1450. #define        (kPlayerInnerRadius,            0.01)
  1451. #define        (kPlayerOuterRadius,            0.9)
  1452. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1453. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1454. #define        (kPlayerLandChaos,            0.8)
  1455. #define        (kPlayerLandClumps,            1)
  1456. #define        (kPlayerFlatChaos,            0.8)
  1457. #define        (kPlayerFlatClumps,            2)
  1458. #define        (kPlayerTreePercentage,            0.04)
  1459.  
  1460.  
  1461. //////////////////////////////////////////////////////////////////////
  1462. // inner neutral definitions
  1463. #define        (kNeutralInnerRadius,            0.05)
  1464. #define        (kNeutralOuterRadius,            0.4)
  1465. #define        (kNeutralOptimalFactor,            0.7)
  1466. #define        (kNumInnerNeutrals,            Between(0, 0))
  1467. #define        (kInnerNeutralPercentLand,        0.35)
  1468. #define        (kInnerNeutralPercentFlat,        Between(.5, .8))
  1469. #define        (kInnerNeutralTreePercentage,          0.04)
  1470. #define        (kInnerNeutralLandChaos,        0.8)
  1471. #define        (kInnerNeutralLandClumps,        1)
  1472. #define        (kInnerNeutralFlatChaos,        0.8)
  1473. #define        (kInnerNeutralFlatClumps,        2)
  1474.  
  1475.  
  1476. //////////////////////////////////////////////////////////////////////
  1477. // outer neutral definitions
  1478. #define        (kNumOuterNeutrals,            Between(0, 0))
  1479. #define        (kOuterNeutralPercentLand,        0.35)
  1480. #define        (kOuterNeutralPercentFlat,        Between(.5, .8))
  1481. #define        (kOuterNeutralTreePercentage,          0.04)
  1482. #define        (kOuterNeutralLandChaos,        0.8)
  1483. #define        (kOuterNeutralLandClumps,        1)
  1484. #define        (kOuterNeutralFlatChaos,        0.8)
  1485. #define        (kOuterNeutralFlatClumps,        2)
  1486.  
  1487.  
  1488. //////////////////////////////////////////////////////////////////////
  1489. // resource definitions
  1490. #define        (kMaxResourceElevation,            2)
  1491. #define        (kResourceToEdgeDistance,        2)
  1492. #define        (kResourceToWaterDistance,        2)
  1493.  
  1494. #define        (kAnimalPerPlayer,            0)
  1495. #define        (kAnimalPerNeutral,            0)
  1496.  
  1497. #define        (kBerryPerPlayer,                0)
  1498. #define        (kBerryPerNeutral,            0)
  1499.  
  1500. #define        (kFishPerPlayer,                7)
  1501. #define        (kFishPerNeutral,                0)
  1502.  
  1503. #define        (kGoldPerPlayer,                1)
  1504. #define        (kGoldPerNeutral,                0)
  1505.  
  1506. #define        (kOilPerPlayer,                0)
  1507. #define        (kOilPerNeutral,                0)
  1508.  
  1509. #define        (kSteelPerPlayer,                1)
  1510. #define        (kSteelPerNeutral,            0)
  1511.  
  1512. #define        (kStonePerPlayer,                1)
  1513. #define        (kStonePerNeutral,            0)
  1514.  
  1515. #define        (kTreePerPlayer,                0)
  1516. #define        (kTreePerNeutral,                0)
  1517.  
  1518. //////////////////////////////////////////////////////////////////////
  1519. // forest definitions
  1520. #define        (kForestFreeRadius,            3)
  1521. #define        (kForestsPerPlayer,            3)
  1522. #define        (kForestChaosLevel,            0.1)
  1523. #define        (kMaxClumpsPerForest,            2)
  1524.  
  1525.  
  1526.  
  1527. //////////////////////////////////////////////////////////////////////
  1528. // End of if...elif... command
  1529. #endif
  1530.  
  1531. #endif        // NOTDEFINED(TOURNAMENT_ISLANDS_TINY_RMV)